Please address the comments from this code review:

## Overall Comments
- The request path, method, and `Content-Type` are now duplicated across the TypeScript client, Go client, and worker handler; consider centralizing these API contract details in a shared definition to avoid future divergence.
- In `isAuthorized`, a misconfigured or missing `RELAYER_AUTH_TOKEN` will cause all requests to be rejected without any signal; consider surfacing this as a clear startup/runtime error or logging a configuration warning so it’s easier to diagnose.

## Individual Comments

### Comment 1
<location> `api/btcindexer/api_test.go:48` </location>
<code_context>
 	pb := PutBlock{Network: NetworkRegtest, Height: 156, Block: blockBz}

-	c := NewClient("http://localhost:8787")
+	c := NewClient("http://localhost:8787", "")
 	resp, err := c.PutBlocks(PutBlocksReq{pb})
 	assert.NilError(t, err)
</code_context>

<issue_to_address>
**suggestion (testing):** Add tests to verify that `NewClient` with a non-empty auth token sets the `Authorization` header in `PutBlocks` requests.

This update only adapts to the new `NewClient` signature and still passes an empty token, so the new auth behavior isn’t actually tested. Please add a test (or table-driven tests) that builds a `Client` with both non-empty and empty `authToken` values, calls `PutBlocks`, and asserts that:

- `Authorization: Bearer <token>` is set when the token is non-empty
- The `Authorization` header is omitted when the token is empty

You can do this by injecting an `http.Client` with a custom `Transport` that captures the outgoing request instead of performing a real HTTP call.

Suggested implementation:

```golang
	pb := PutBlock{Network: NetworkRegtest, Height: 156, Block: blockBz}

	c := NewClient("http://localhost:8787", "")
	resp, err := c.PutBlocks(PutBlocksReq{pb})
	assert.NilError(t, err)
	respBody, err := io.ReadAll(resp.Body)

}

func TestClientPutBlocksAuthorizationHeader(t *testing.T) {
	tests := []struct {
		name     string
		token    string
		wantAuth string
	}{
		{
			name:     "no auth token omits Authorization header",
			token:    "",
			wantAuth: "",
		},
		{
			name:     "non-empty auth token sets Authorization header",
			token:    "my-secret-token",
			wantAuth: "Bearer my-secret-token",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var capturedReq *http.Request

			// Custom RoundTripper that captures the request instead of doing a real HTTP call.
			rt := roundTripperFunc(func(req *http.Request) (*http.Response, error) {
				capturedReq = req

				// Return a minimal successful HTTP response so PutBlocks can proceed.
				return &http.Response{
					StatusCode: http.StatusOK,
					Body:       io.NopCloser(strings.NewReader(`{}`)),
					Header:     make(http.Header),
					Request:    req,
				}, nil
			})

			httpClient := &http.Client{
				Transport: rt,
			}

			client := NewClient("http://localhost:8787", tt.token)

			// Inject our custom HTTP client so we can capture the outgoing request.
			client.httpClient = httpClient

			_, err := client.PutBlocks(PutBlocksReq{})
			assert.NilError(t, err)

			if capturedReq == nil {
				t.Fatalf("expected request to be captured")
			}

			gotAuth := capturedReq.Header.Get("Authorization")
			if tt.wantAuth == "" {
				if gotAuth != "" {
					t.Fatalf("expected no Authorization header, got %q", gotAuth)
				}
			} else {
				if gotAuth != tt.wantAuth {
					t.Fatalf("expected Authorization header %q, got %q", tt.wantAuth, gotAuth)
				}
			}
		})
	}

```

1. Ensure the following helper type is defined in this file (at top-level, outside any function), to satisfy `http.RoundTripper`:

```go
type roundTripperFunc func(*http.Request) (*http.Response, error)

func (f roundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) {
	return f(req)
}
```

2. Make sure the `Client` type used by `NewClient` exposes a way to inject a custom `*http.Client`. The test above assumes a field `httpClient`:
   ```go
   type Client struct {
       baseURL    string
       authToken  string
       httpClient *http.Client
   }
   ```
   If this field is not currently exported/available, either:
   - Add it to `Client`, initialized in `NewClient` (e.g., `httpClient: http.DefaultClient`), and keep using it inside `PutBlocks`, or
   - Provide a setter method (e.g., `func (c *Client) SetHTTPClient(hc *http.Client)`) and update the test to call that instead of assigning the field directly.

3. Confirm the following imports exist at the top of `api/btcindexer/api_test.go`:
   ```go
   import (
       "io"
       "net/http"
       "strings"
       "testing"

       "gotest.tools/v3/assert"
   )
   ```
   Adjust to match existing import style and any additional imports already present.
</issue_to_address>